Article | cleb.dev

Kit 37|45 em 1 modulos e sensores para Arduino

Hoje, abordaremos um daqueles kits que são adquiridos quando vamos comprar alguns sensores para arduino. O tal do kit 37 em 1 (ou 45 em 1), este que comporta vários modulos e sensores simples e de uso básico para arduino, raspberry, entre outros. Para não falar muito sobre cada item vamos apenas resumir o básico e passar o código de cada item.

Dependendo de onde adquirir o kit, você pode acabar tendo problemas com módulos mal soldados, mal funcionamento ou até “falsos” (Meu caso), não se preocupe, eles também vão atender as suas necessidades, só tem que se lembrar sempre de verificar se o resistor de boa parte deles estão na posição correta em relação ao datasheet :).

Vamos aos módulos...

Começando com os que quase sempre vem nos kits 37 em 1, que são os módulso mais básicos e que em sua maioria funcionam como Switches, enviando um sinal de nível alto/baixo quando detectam alguma coisa. Possuindo um código de funcionamento simples. Abaixo vamos mostrar uma imagem do tal sensor e o codigo em C/C++ para Arduino IDE do mesmo.

Módulo ky-001: Sensor de Temperatura DS18B20

Este módulo comporta um sensor de temperatura DS18B20 (O mesmo que vem naqueles sensores a prova d'agua, não se engane e não tente mergulhar esse cara aqui), um resistor SMD de 4,7k oms e um led SMD indicador, algumas características são:

Precisão de ±0.5ºC com suporte de -55ºC até 125ºC;
Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são GND, VCC, SIGNAL (Output Digital);
Para usar este sensor é preciso usar as bibliotecas necessárias para o DS18B20.

#include <OneWire.h>
#include <DallasTemperature.h>
#define pinKY001 3

OneWire oneWire(pinKY001);
DallasTemperature ds18b20(&oneWire);
void setup() {
  Serial.begin(9600);
  ds18b20.begin();
}

void loop() {
  ds18b20.requestTemperatures(); 
  Serial.print("Temperatura: ");
  Serial.print(ds18b20.getTempCByIndex(0));
  Serial.println("*C.");
}

Módulo ky-002: Sensor de Vibração/Impacto

Este sensor trata-se de um switch básico, quando deteca vibrações fortes, ele fecha o circuito e envia um sinal de nivel alto para a porta de saída, comporta um resistor SMD de 10k oms para limitar a corrente, algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT DIGITAL), VCC, GND*;
Para usar este sensor não é preciso nenhuma biblioteca;
*Se o resistor estiver fazendo contato com o GND (ficando do lado direito), então trata-se de um sensor mal montado, nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte, o ‘S’ é o GND, o do meio o VCC e o ‘-’ o de signal.

#define pinKY002 3 

/**
  * Configuração do pino do KY-002 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY002, INPUT); 
} 

/**
  * lendo o valor do pino e armazenando em uma variável.
  * Se o sensor for vibrado o led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY002); 
  digitalWrite(LED_BUILTIN, !var);
}

Módulo ky-003: Sensor Magnético

Este sensor trata-se de um switch básico, quando deteca um campo magnético na sua proximidade, ele interrompe o circuito e envia um sinal de nivel baixo para a porta de saída, comporta um resistor SMD de 680 oms e um led indicador, algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são GND, VCC, e SIGNAL (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY003 3 

/**
  * Configuração do pino do KY-003 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY003, INPUT); 
} 

/**
  * lendo o valor do pino e armazenando em uma variável.
  * Se o sensor detectar um campo magnetico o 
  * led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY003); 
  digitalWrite(LED_BUILTIN, !var);
}

Módulo ky-004: Botão Simples

Este sensor trata-se de um switch básico, quando o botão é pressionado, ele fecha o circuito e envia um sinal de nivel alto para a porta de saída, comporta um resistor SMD de 10k oms, algumas características são:

Possuir alimentação de 3,3v à 5v (50mA no mínimo);
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT DIGITAL), VCC, GND*;
Para usar este sensor não é preciso nenhuma biblioteca;
*Se o resistor estiver fazendo contato com o GND (ficando do lado direito), então trata-se de um módulo mal montado, nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte, o ‘S’ é o GND, o do meio o VCC e o ‘-’ o de signal.

#define pinKY004 3 

/**
  * Configuração do pino do KY-004 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY004, INPUT); 
} 

/**
  * lendo o valor do pino e armazenando em uma variável.
  * Se o botão for pressionado o led é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY004); 
  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-005: Emissor IR (Infra-vermelho)

Este módulo trata-se de um led emissor de infra-vermelho em uma determinada frequência (Não fique encarando diretamente o módulo quando estiver funcionando), usado para enviar comandos simples, sendo necessário usar junto com o módulo ky-022 (O Receptor infravermelho), algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (INPUT DIGITAL DO MODULO), VCC, GND;
Para usar este módulo, é necessário usar a biblioteca IRremote tanto para este módulo quanto para o ky-022;

#include <IRremote.hpp>
#define pinKY005 3

const uint16_t sAddress = 0x0102;
const uint8_t sCommand = 0x10; // Comando a ser enviado

// Configuração dos pinos do KY-005.
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);
  IrSender.begin(pinKY005, DISABLE_LED_FEEDBACK);
}
// emitindo mensagem pelo emissor. 
void loop () {
  IrSender.sendNEC(sAddress, sCommand, 0);
  delay(100);
}

Módulo ky-006: Buzzer Passivo

Este módulo trata-se de um Buzzer, que emite ‘sons’ de diferentes frequências (Não vai tocar rock nem nada), a diferença dele para o Buzzer normal (além do sinal de “+”) é que este pode emitir diferentes tons, algumas características são:

Possuir alimentação de 3v à 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (INPUT DIGITAL DO MODULO), NC (O pino do meio não é conectado), GND;
Para usar este módulo não é necessário nenhuma biblioteca, já que o arduino possui a função padrão tone();

#define pinKY006 3

const int frequencia = 1000;
/**
    Configuração do pino do KY-006 como saida
  **/
void setup () {
  pinMode(pinKY006, OUTPUT);
}

/**
  *  buzzer passivo emite som com uma determinada 
  *  frequencia na função tone(pinoBuzzer, frequencia).
  **/
void loop () {
  tone(pinKY006, frequencia);
  delay(1000);
  tone(pinKY006, frequencia * 2);
  delay(1000);
  tone(pinKY006, frequencia * 3);
  delay(1000);
  noTone(pinKY006);
  delay(1000);
}

Módulo ky-008: Emissor Laser

Este módulo comporta um emissor de luz laser de cor vermelha (Não aponte no olho), algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (Input Digital), NC (Pino do meio não é conectado) e GND;
Para usar este módulo não é necessário nenhuma biblioteca;
O Resistor mesmo que esteja na posição errada não interfere em nada já que o pino do meio não é usado.

#define pinKY008 3

/**
  * Configuração do pino do KY-008 como saida
  **/
void setup () {
  pinMode(pinKY008, OUTPUT);
}

/**
  * liga o laser e aguarda 1 segundo para desligar
  **/
void loop () {

  digitalWrite(pinKY008, HIGH);
  delay(1000);
  digitalWrite(pinKY008, LOW);
  delay(1000);
}

Módulo ky-009: LED RGB SMD

Este módulo trata-se de um led SMD que emite cores na escala RGB (RED, GREEN, BLUE), assim podendo emitir inumeras cores diferentes usando a combinação destas três, algumas características são:

Possuir alimentação de no máximo 5v (Nos pinos de cada cor);
Possuir 4 pinos machos, da esquerda pra direita são SIGNAL B (BLUE), SIGNAL G (GREEN), SIGNAL R (RED), GND;
Para usar este sensor não é preciso nenhuma biblioteca;
Todos os pinos de cores são de inputs para o módulo, então defina como OUTPUT na placa em questão.

#define pinKY009_R 3 // Pin com função PWM "~"
#define pinKY009_G 5 // Pin com função PWM "~"
#define pinKY009_B 6 // Pin com função PWM "~"
/**
  * Configuração dos pinos RGB do KY-009 como saidas
  **/
void setup () {
  pinMode(pinKY009_R, OUTPUT);
  pinMode(pinKY009_G, OUTPUT);
  pinMode(pinKY009_B, OUTPUT);
}

/**
  * muda as cores do led de acordo com os valores rgb
  **/
void loop () {
  set_color(250, 0, 0); // vermelho
  delay(500);
  set_color(0, 250, 0); // verde
  delay(500);
  set_color(0, 0, 250); // azul
  delay(500);
  
  for(int i = 0; i < 255; i++){ // Mudança gradual de cor
    set_color(i, 254 - i, 128 - i);
    delay(10);
  }
}

Módulo ky-010: Foto interruptor

Este módulo trata-se de um switch básico, constinui de um emissor e um detector de luz de frente um para outro, quando alguma coisa bloqueia o sinal de luz no meio do módulo (a parte pretinha), este aciona e envia um sinal de nivel alto para a porta de saída, e possui dois resistores na parte de trás, um de 1k oms e outro de 330 oms, algumas características são:

Possuir alimentação de 3,3v à 5v;
Possuir 3 pinos machos (a marcação fica na parte de trás), da esquerda pra direita são GND, VCC, e SIGNAL (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY010 3 
/**
  * Configuração do pino do KY-010 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinKY010, INPUT);
}

/**
  * Sensor aciona o led quando um obstáculo obstrui
  **/
void loop () {
  int var = digitalRead(pinKY010);
  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-011: Led 2 cores

Este módulo trata-se de um led básico de duas cores, vermelho e verde, algumas características são:

Possuir alimentação de 2v à 3v (Necessário usar outros resistores de 330 oms nos pinos para limitar a corrente);
Possuir 3 pinos macho, da esquerda pra direita são SIGNAL G (INPUT PMW), SIGNAL R (INPUT PWM), GND;
Para usar este sensor não é preciso nenhuma biblioteca;

*Desmontei o meu então não tenho uma imagem minha dele pra mostrar.

#define pinKY011_R 5 // Pin com função PWM "~"
#define pinKY011_G 6 // Pin com função PWM "~"
/**
  * Configuração dos pinos R e G do KY-011 como saidas
  **/
void setup () {
  pinMode(pinKY011_R, OUTPUT);
  pinMode(pinKY011_G, OUTPUT);
}

/**
  * muda as cores do led de acordo com os valores R e G
  **/
void loop () {
  set_color(250, 0); // vermelho
  delay(500);
  set_color(0, 250); // verde
  delay(500);
  
  for(int i = 0; i < 255; i++){ // Mudança gradual de cor
    set_color(i, 254 - i);
    delay(10);
  }
}

void set_color(int r, int g){
  analogWrite(pinKY011_R, r); 
  analogWrite(pinKY011_G, g); 
}

Módulo ky-012: Buzzer ativo

Este módulo trata-se de um buzzer emissor de som em uma determinada frequência, diferente do ky-006, este não permite mudar a frequencia emitida, algumas características são:

Possuir alimentação de 3,3v à 5v;
Possuir 3 pinos macho, da esquerda pra direita são SIGNAL (INPUT DIGITAL DO MODULO), NC (Não conectado), GND*;
Para usar este módulo não é preciso nenhuma biblioteca;
*Se o ‘S’ estiver do lado direito, então nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte.

#define pinKY012 3

/**
    Configuração do pino do KY-012 como saida
  **/
void setup () {
  pinMode(pinKY012, OUTPUT);
}

/**
  *  buzzer ativo emite som com uma frequencia padrão.
  **/
void loop () {
  digitalWrite(pinKY012, HIGH);
  delay(1000);
  digitalWrite(pinKY012, LOW);
  delay(1000);
}

Módulo ky-013: Sensor de temperatura analógica

Este módulo comporta um termistor ntc analógico de 10k (Alguns sensores a prova d'agua podem ter um carinha desse, não se engane e não tente mergulhar esse cara aqui), um resistor SMD de 10k oms e um led SMD indicador, algumas características são:

Precisão de ±0.5ºC com suporte de -55ºC até 125ºC;
Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (Output Analógico), VCC e GND;
Para usar este sensor é preciso usar as bibliotecas padrão math e fazer o calculo de temperatura do termistor junto com o resistor usado nele usando o fator beta.

#include "math.h"

#define pinKY013 A0
/**
  * Cálculo de temperatura de termistor ntc usando fator beta. 
  * 
  * Inspirado por:
  * https://thecustomizewindows.com/2020/10/temperature-sensor-using-ntc-thermistor-arduino-ntc/
  * 
  * Para calcular as resistencias do termistor em uma determinada temperatura e verificar com multimetro.
  * https://www.lasercalculator.com/ntc-thermistor-calculator/
  *
  **/
const float ntc_ohms = 10000; // Resistencia em Ω ohms do ntc
const float res_ohms = 10000; // Resistencia em Ω ohms do resistor
const float t_0 = 25.0; // Temperatura do ntc na resistencia maxima definida
const float beta = 4000; // Fator beta do ntc

const float VCC = 5.0;
const float K = 273.15; // temperatura constante de kelvin
const float T_K = t_0 + K; // temperatura final kelvin

/**
    Configuração do pino do KY-013 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(pinKY013, INPUT);
}

/**
    Calculado os valores de temperatura através da equação
  **/
void loop () {
  float val =  analogRead(pinKY013);

  float V_L = val * (VCC / 1023.0); // convertendo a leitura do termistor em voltagem
  float V_R = VCC - V_L; // pega o valor do "resto de corrente"
  float R = V_L / (V_R / res_ohms); // calculando resistencia final
  float ln = log(R / ntc_ohms); // logaritmo do resistor para o Termistor.
  float temp_K = (1 / ((ln / beta) + (1 / T_K))); // Temperatura do termistor em kelvin
  float temp_C = temp_K - K; // Temperatura em Celcius

  Serial.print("Temperatura: ");  Serial.print(temp_K);  Serial.print(" ºK, ");
  Serial.print(temp_C); Serial.print(" ºC");
  Serial.println();
}

Módulo ky-015: Sensor de temperatura e umidade DHT11

Este módulo comporta um sensor digital de temperatura e umidade do ar DHT11, um resistor SMD de 10k oms, algumas características são:

Precisão de ± 2.0ºC com suporte de 0ºC até 50ºC;
Precisão de ± 5% RH com suporte de 20% até 90% de Umidade Relativa do ar ;
Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (Output Digital), VCC e GND;
Para usar este sensor é preciso usar as bibliotecas do DHT.

#include <DHT.h>

#define pinKY015 3

/*
 * Defindo o sensor dht que é usado pelo modulo (DHT11).
 **/
DHT dht11(pinKY015, DHT11); 
/**
  * Configuração do modulo 
  **/
void setup () {
  Serial.begin(9600);
  dht11.begin();
}

/**

 **/
void loop () {
  /**
   * A leitura da temperatura ou umidade pode levar aprximadamente 300ms
   * O atraso do sensor pode chegar a 2 segundos
   **/
  float tempAr = dht11.readTemperature(); // lê a temperatura em Graus Celsius
  float umidAr = dht11.readHumidity(); // lê a umidade em %

  if (isnan(umidAr) || isnan(tempAr)) {
    Serial.println("Falha na leitura do Sensor DHT11!");
  }
  else {
    Serial.print("Temperatura do Ar: ");
    Serial.print(tempAr);
    Serial.print(" *C");

    Serial.print(" || "); 

    Serial.print("Umidade: ");
    Serial.print(umidAr);
    Serial.print(" %");

    Serial.println();
  }
  delay(1000);
}

Módulo ky-016: LED RGB

Este módulo trata-se de um led que emite cores na escala RGB (RED, GREEN, BLUE), assim podendo emitir inumeras cores diferentes usando a combinação destas três, algumas características são:

Possuir alimentação de no máximo 5v (Nos pinos de cada cor);
Possuir 4 pinos machos, da esquerda pra direita são SIGNAL B (BLUE), SIGNAL G (GREEN), SIGNAL R (RED), GND;
Para usar este sensor não é preciso nenhuma biblioteca;
Todos os pinos de cores são de inputs para o módulo, então defina como OUTPUT na placa em questão.


#define pinKY016_R 3 // Pin com função PWM "~"
#define pinKY016_G 5 // Pin com função PWM "~"
#define pinKY016_B 6 // Pin com função PWM "~"
/**
  * Configuração dos pinos RGB do KY-016 como saidas.
  * Diferença para o KY-009 é que esse não precisa de 
  * resistores nos pinos
  **/
void setup () {
  pinMode(pinKY016_R, OUTPUT);
  pinMode(pinKY016_G, OUTPUT);
  pinMode(pinKY016_B, OUTPUT);
}

/**
  * muda as cores do led de acordo com os valores rgb
  **/
void loop () {
  set_color(250, 0, 0); // vermelho
  delay(500);
  set_color(0, 250, 0); // verde
  delay(500);
  set_color(0, 0, 250); // azul
  delay(500);
  
  for(int i = 0; i < 255; i++){ // Mudança gradual de cor
    set_color(i, 254 - i, 128 - i);
    delay(10);
  }
}

void set_color(int r, int g, int b){
  analogWrite(pinKY016_R, r); 
  analogWrite(pinKY016_G, g); 
  analogWrite(pinKY016_B, b); 
}

Módulo ky-017: Interruptor de mercúrio por inclinação

Este módulo trata-se de um switch básico, quando ele é inclinado, a bolinha de mercurio faz contato fechando o circuito (Se quebrar, favor não ingerir o mercúrio e nem pegue nele com a mão sem proteção), enviando um sinal de nivel alto para a porta de saída, comporta um resistor SMD de 680 oms para limitar a corrente e um led que aciona quando ocorre o fechamento, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são GND, VCC, SIGNAL (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;


#define pinKY017 3 
/**
  * Configuração do pino do KY-017 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinKY017, INPUT);
}

/**
  * Sensor aciona o led quando o mercurio é mechido 
  **/
void loop () {
  int var = digitalRead(pinKY017);
  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-018: Sensor de intensidade de luz LDR

Este sensor, trata-se de um led que varia sua resistencia de acordo com a incidência da luz sobre o mesmo, enviando um sinal analógico a porta de saída, comporta um resistor SMD de 10k oms para limitar a corrente, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT DIGITAL), VCC, GND*;
Para usar este sensor não é preciso nenhuma biblioteca;
*Se o resistor estiver fazendo contato com o GND (ficando do lado direito), então trata-se de um sensor mal montado, nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte, o ‘S’ é o GND, o do meio o VCC e o ‘-’ o de signal.

#define pinKY018 A0
/**
  * Configuração do pino do KY-018 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(pinKY018, INPUT);
}

/**
  * Sensor varia a resistencia com a intencidade de luz
  **/
void loop () {
  float var = analogRead(pinKY018);
  Serial.println(var);
  delay(100);
}

Módulo ky-019: Relé

Este módulo comporta um módulo relé, para fazer o acionamento de componentes eletronicos, como lâmpadas e bombas d'agua para irrigação, algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (Input Digital), VCC e GND;
Para usar este módulo não é necessário nenhuma biblioteca;

*Desmontei o meu então não tenho uma imagem minha dele pra mostrar.

#define pinKY019 3
/**
  * Configuração do pino do KY-019 como saida
  **/
void setup () {
  pinMode(pinKY019, OUTPUT);
}

/**
  * aciona o rele e faz a ligação da corrente.
  * Estado padrão do rele é [NC <-> MEIO], [NO]. 
  * Ao acionar passa a ser [NC], [MEIO <-> NO]
  **/
void loop () {
  digitalWrite(pinKY019, HIGH); // Liga rele
  delay(1000);
  digitalWrite(pinKY019, LOW); // desliga rele
  delay(1000);
}

Módulo ky-020: Interruptor de inclinação

Este módulo trata-se de um switch básico, quando ele é movimentado acaba fazendo contato fechando o circuito, enviando um sinal de nivel alto para a porta de saída, comporta um resistor SMD de 10k oms para limitar a corrente, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT DIGITAL), VCC, GND;
Para usar este sensor não é preciso nenhuma biblioteca;
*Se o resistor estiver fazendo contato com o GND (ficando do lado direito), então trata-se de um sensor mal montado, nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte, o ‘S’ é o GND, o do meio o VCC e o ‘-’ o de signal.

#define pinKY020 3 
/**
  * Configuração do pino do KY-020 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinKY020, INPUT);
}

/**
  * Sensor aciona o led quando é mechido bruscamente
  **/
void loop () {
  int var = digitalRead(pinKY020);
  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-021: Interruptor Magnético

Este módulo trata-se de um switch básico, quando ele ocorre a presença de magnetismo acaba interrompendo o fluxo de corrente, enviando um sinal de nivel baixo para a porta de saída, comporta um resistor SMD de 10k oms para limitar a corrente, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT DIGITAL), VCC, GND;
Para usar este sensor não é preciso nenhuma biblioteca;
*Se o resistor estiver fazendo contato com o GND (ficando do lado direito), então trata-se de um sensor mal montado, nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte, o ‘S’ é o GND, o do meio o VCC e o ‘-’ o de signal.

#define pinKY021 3
/**
  * Configuração do pino do KY-021 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinKY021, INPUT);
}

/**
  * Modulo aciona o circuito na presença de magnetismo
  **/
void loop () {
  int val = digitalRead(pinKY021, HIGH); 
  digitalWrite(LED_BUILTIN, val); 
}

Módulo ky-022: Receptor IR (Infra-vermelho)

Este módulo trata-se de um led receptor de infra-vermelho em uma determinada frequência, usado para receber comandos simples, sendo necessário usar junto com o módulo ky-005 (O Emissor infravermelho), algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são GND, VCC, SIGNAL (INPUT DIGITAL DO MODULO);
Para usar este módulo, é necessário usar a biblioteca IRremote tanto para este módulo quanto para o ky-005;

#include <IRremote.hpp>
#define pinKY022 4

//  Configuração dos pinos KY-022.
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  IrReceiver.begin(pinKY022, DISABLE_LED_FEEDBACK);
}
// emitindo mensagem pelo emissor. 
// Recebendo e decodificando pelo receptor.
void loop () {
	if (IrReceiver.decode()) {
  		Serial.println(IrReceiver.decodedIRData.decodedRawData, HEX);
  		IrReceiver.printIRResultShort(&Serial); // opcional
  		Serial.println();
  		Serial.print(F("Protocolo: "));
  		Serial.print(getProtocolString(IrReceiver.decodedIRData.protocol));
  		Serial.print(F("Dados Recebidos: "));
  		Serial.print(IrReceiver.decodedIRData.decodedRawData, HEX);
  		Serial.print(F(", Endereço: "));
  		Serial.print(IrReceiver.decodedIRData.address, HEX);
  		Serial.print(F(", Comando: "));
  		Serial.println(IrReceiver.decodedIRData.command, HEX);
  		
  		IrReceiver.resume(); // Ativa pra receber o proximo valor
  		if (IrReceiver.decodedIRData.command == 0x10) {
    		digitalWrite(LED_BUILTIN, HIGH);
  		} 
  	}
    delay(100);
}

Módulo ky-023: Joystick

Este módulo trata-se de um joystick (Que nem aqueles do playstation) onde podemos pegar as posições x e y do eixo e o acionamento do botão, usado para controlar alguns componentes, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 5 pinos machos, da esquerda pra direita são GND, VCC, VRx (OUTPUT ANALÓGICO), VRy (OUTUPUT ANALÓGICO), SW (OUTPUT);
Para usar este módulo,não é necessário nenhuma biblioteca;

#define pinKY023_X A0
#define pinKY023_Y A1
#define pinKY023_BTN 3

void setup() {
  pinMode(pinKY023_X, INPUT);
  pinMode(pinKY023_Y, INPUT);
  pinMode(pinKY023_BTN, INPUT); 
  Serial.begin(9600);
}

void loop() {

  int x = analogRead(pinKY023_X); 
  int y = analogRead(pinKY023_Y);
  int btn = digitalRead(pinKY023_BTN);
   
  Serial.print("X:");
  Serial.print(x, DEC);
  Serial.print(" | ");
  Serial.print("Y:");
  Serial.print(y, DEC);
  Serial.print(" | ");
  Serial.print("BTN:");
  Serial.println(btn);
  Serial.println();

  delay(100);
}

Módulo ky-024: Sensor Magnético Linear de Efeito Hall

Este sensor trata-se de um switch que também comporta uma saída analógica, que pode ser regulada, quando deteca um campo magnético na sua proximidade, ele interrompe o circuito e envia um sinal de nivel alto para a porta de saída, este módulo é similar ao ky-003, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibilidade do acionamento do módulo

#define pinKY024_A A0
#define pinKY024_D 3 

/**
  * Configuração do pino do KY-024 como entrada
  * Similar ao KY-003
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY024_A, INPUT); 
  pinMode(pinKY024_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se o sensor detectar um campo magnetico o 
  * led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY024_D); 
  digitalWrite(LED_BUILTIN, var);
  
  int analogVar = analogRead(pinKY024_A);
  Serial.println(analogVar); 
  delay(100);
}

Módulo ky-025: Interruptor Magnético

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibilidade de acionamento do módulo

#define pinKY025_A A0
#define pinKY025_D 3 

/**
  * Configuração do pino do KY-025 como entrada
  * Similar ao KY-021
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY025_A, INPUT); 
  pinMode(pinKY025_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se um campo magnético fechar o circuito o 
  * led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY025_D); 
  digitalWrite(LED_BUILTIN, var);
  
  int analogVar = analogRead(pinKY025_A);
  Serial.println(analogVar); 
  delay(100);
}

Módulo ky-026: Detector de Chamas

Este sensor trata-se de um switch que também comporta uma saída analógica, que pode ser regulada, quando deteca a luz infravermelha do calor das chamas, e envia um sinal de nivel alto para a porta de saída, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibilidade de acionamento do módulo

#define pinKY026_A A0
#define pinKY026_D 3 

/**
  * Configuração dos pinos do KY-026 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY026_A, INPUT); 
  pinMode(pinKY026_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se o sensor detectar luz infra vermelha emitida 
  * pelas chamas, o led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY026_D); 
  digitalWrite(LED_BUILTIN, var);
  
  int analogVar = analogRead(pinKY026_A);
  Serial.println(analogVar); 
  delay(100);
}

Módulo ky-027: Interruptor de mercúrio por inclinação com Luz mágica

Este módulo, trata-se de dois switches similar ao ky-017 quando ele é inclinado, a bolinha de mercurio (Se quebrar, favor não ingerir o mercúrio e nem pegue nele com a mão sem proteção) faz contato fechando o circuito, enviando um sinal de nivel alto para a porta de saída, este módulo possui um led com função PWM, e servem pra serem usados para os dois em pontos diferentes para verificar a inclinação, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são GND, VCC, SIGNAL (OUTPUT DIGITAL), L (INPUT PWM);
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY027_A_A 2 // Pino do Mercurio A
#define pinKY027_D_A 3 // Pino digital com função PWM "~"
#define pinKY027_A_B 4 // Pino do Mercurio B
#define pinKY027_D_B 5 // Pino digital com função PWM "~"

int brightness = 0;

void setup() 
{
  pinMode(pinKY027_A_A, OUTPUT); 
  pinMode(pinKY027_A_B, OUTPUT);  
  pinMode(pinKY027_D_A, INPUT); 
  pinMode(pinKY027_D_B, INPUT);
}

void loop() 
{
  int stateA = digitalRead(pinKY027_D_A);
  int stateB = digitalRead(pinKY027_D_B);
  
  if (stateA && brightness < 255)
  { 
   brightness ++;
  } 
  if (stateB && brightness > 0)
  { 
   brightness --;
  } 
  analogWrite(pinKY027_D_A, brightness);  //  Led de A
  analogWrite(pinKY027_D_B, 255 - brightness);  // Led de B
  delay(10);
}

Módulo ky-028: Sensor digital de temperatura

Este sensor trata-se de um switch que também comporta uma saída analógica, que pode ser regulada, de acordo com a temperatura desejada, e envia um sinal de nivel alto para a porta de saída.

Este módulo, diferente do ky-013 não permite o uso do fator beta para calcular a sua temperatura, visto que o valor analógico está diretamente relacionado ao potenciomêtro, podento ter apenas um valor relativo, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibilidade do acionamento do módulo

#define pinKY028_A A0
#define pinKY028_D 3 

/**
  * Configuração dos pinos do KY-028 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY028_A, INPUT); 
  pinMode(pinKY028_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se a temperatura for a definida pelo potenciometro
  * o led é aceso.
  **/
void loop () {
  int var = digitalRead (pinKY028_D); 
  digitalWrite(LED_BUILTIN, var);
  
  int analogVar = analogRead(pinKY028_A);
  Serial.println(analogVar, DEC); 
  delay(100);
}

Módulo ky-029: Led 2 cores

Este módulo trata-se de um led básico de duas cores, vermelho e verde, praticamente igual ao ky-011, algumas características são:

Possuir alimentação de 2v à 3v (Necessário usar outros resistores de 330 oms nos pinos para limitar a corrente);
Possuir 3 pinos macho, da esquerda pra direita são GND, SIGNAL R (INPUT PWM), SIGNAL G (INPUT PWM);
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY029_R 5 // Pin com função PWM "~"
#define pinKY029_G 6 // Pin com função PWM "~"
/**
  * Configuração dos pinos R e G do KY-029 como saidas
  **/
void setup () {
  pinMode(pinKY029_R, OUTPUT);
  pinMode(pinKY029_G, OUTPUT);
}

/**
  * muda as cores do led de acordo com os valores R e G
  **/
void loop () {
  set_color(250, 0); // vermelho
  delay(500);
  set_color(0, 250); // verde
  delay(500);
  
  for(int i = 0; i < 255; i++){ // Mudança gradual de cor
    set_color(i, 254 - i);
    delay(10);
  }
}

void set_color(int r, int g){
  analogWrite(pinKY029_R, r); 
  analogWrite(pinKY029_G, g); 
}

Módulo ky-031: Sensor de impácto

Este módulo trata-se de um switch básico, quando ele é movimentado bruscamente acaba fazendo contato fechando o circuito, enviando um sinal de nivel baixo para a porta de saída, comporta um resistor SMD de 10k oms para limitar a corrente, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT DIGITAL), VCC, GND;
Para usar este sensor não é preciso nenhuma biblioteca;
*Se o resistor estiver fazendo contato com o GND (ficando do lado direito), então trata-se de um sensor mal montado, nesse caso ignore a ordem das portas mencionadas anteriormente e use a seguinte, o ‘S’ é o GND, o do meio o VCC e o ‘-’ o de signal.

#define pinKY031 3 

/**
  * Configuração do pino do KY-031 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY031, INPUT); 
} 

/**
  * lendo o valor do pino e armazenando em uma variável.
  * Se o sensor for vibrado por batidas ou mexido 
  * o led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY031); 
  digitalWrite(LED_BUILTIN, !var);
}

Módulo ky-032: Sensor de obstáculo IR

Este módulo é bastante usado em projetos de robótica, trata-se de um sensor e receptor infra-vermelho, quando um obstaculo surge na frente deste sensor, a luz infravermelha é refletida e volta ao receptor, fechando um circuito e enviando um sinal de nivel baixo na porta de saída, é possivel programar para ligar e desligar o emissor, entretanto não é muito util e algumas vezes não funciona, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são GND, VCC, OUT (OUTPUT DIGITAL), EN (INPUT DIGITAL PRO EMISSOR);
Trimpodes (Potenciomêtros) para regulagem da sensibilidade do sensor;
Para usar este sensor não é preciso nenhuma biblioteca;
*No meu caso o meu sensor possui EN, VCC, OUT e GND como pinos nesta ordem.

#define pinKY032_D 3 // Pino do detector de obstaculo
/**
  * Configuração do pino do KY-032 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY032_D, INPUT); // Pino OUT do módulo
} 
/**
  * lendo o valor do pino e armazenando em uma variável.
  * Se o sensor detectar um obstaculo pelo led IR.
  * O led é aceso.
  **/
void loop () {
  int var = digitalRead (pinKY032_D); 
  digitalWrite(LED_BUILTIN, !var);
}

Módulo ky-033: Sensor reflexivo IR (Sensor de linha)

Este módulo é bastante usado em projetos de robótica, trata-se de um emissor e receptor de pulsos infra-vermelho, quando mirado numa superficie esta reflete a luz IR do sensor ele envia um sinal de nível baixo, mas quando este passa por uma superficie escura não reflexiva (Uma faixa preta), esta absorve a luz acionando o módulo, enviando um sinal de nivel alto na porta de saída, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são GND, VCC, OUT (OUTPUT DIGITAL);
Possui um Trimpode (Potenciomêtro) para regulagem da sensibilidade do sensor;
Para usar este sensor não é preciso nenhuma biblioteca;
*No meu caso o meu sensor possui GND, OUT e VCC como pinos nesta ordem.

#define pinKY033 3 

/**
  * Configuração do pino do KY-033 como entrada
  **/
void setup () {
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY033, INPUT); 
} 

/**
  * lendo o valor do pino e armazenando em uma variável.
  * Se o sensor detectar uma faixa escura pelo modulo 
  * o led do arduino é acionado.
  **/
void loop () {
  int var = digitalRead (pinKY033); 
  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-034: LED Flash de 7 Cores

Este módulo é um simples LED que pisca 7 cores diferentes conforme permanece acionado, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (INPUT DIGITAL), NC (NÃO CONECTADO), GND;
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY034 3 

/**
  * Configuração do pino do KY-034 como saída
  **/
void setup () {
  pinMode(pinKY034, OUTPUT); 
} 

/**
  * escreve o valor HIGH no pino do led para acende-lo.
  * espera 5 segundos, então apaga o led por 1 segundo.
  **/
void loop () {
  digitalWrite (pinKY034, HIGH);
  delay(5000);
  digitalWrite (pinKY034, LOW);
  delay(1000); 
}

Módulo ky-035: Sensor magnético analógico de efeito Hall

Este módulo é um simples sensor magnético que envia um sinal analógico conforme detecta campo magnético, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 3 pinos machos, da esquerda pra direita são GND, VCC, SIGNAL (OUTPUT ANALÓGICO);
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY035 A0

/**
  * Configuração do pino do KY-035 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(pinKY035, INPUT); 
} 

/**
  * lÊ o valor do sensor magnético e imprime na serial.
  **/
void loop () {
  int val = analogRead (pinKY035);
  Serial.print("Valor obtido aproximado >>> ");
  Serial.println(val);
  delay(100); 
}

Módulo ky-036: Sensor de Toque

Este sensor trata-se de um switch que também comporta uma saída analógica, que pode ser regulada, funciona detectando o toque do usuário no sensor do módulo, e envia um sinal de nivel alto para a porta de saída., possuindo as seguintes caracteristicas:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibilidade do acionamento do módulo

#define pinKY036_A A0 
#define pinKY036_D 3 

/**
  * Configuração dos pinos do KY-036 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY036_A, INPUT);
  pinMode(pinKY036_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se o sensor um toque o led acende, o valor analógico 
  * é impresso na serial.
  **/
void loop () {
  int analogVal = analogRead (pinKY036_A);
  int digVal = digitalRead (pinKY036_D);

  Serial.println(analogVal);

  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-037: Sensor de som GRANDE

Este sensor trata-se de um switch a base de som que também comporta uma saída analógica, que pode ser regulada, de acordo com a sensibilidade do som desejado, semelhante ao módulo ky-038, e envia um sinal de nivel alto para a porta de saída, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibildiade acionamento do módulo

#define pinKY037_A A0 
#define pinKY037_D 3 

/**
  * Configuração dos pinos do KY-037 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY037_A, INPUT);
  pinMode(pinKY037_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se o sensor detectar um som é então acionado, 
  * o valor analógico é impresso na serial.
  **/
void loop () {
  int analogVal = analogRead (pinKY037_A);
  int digVal = digitalRead (pinKY037_D);

  Serial.println(analogVal);

  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-038: Sensor de som PEQUENO

Este sensor trata-se de um switch a base de som que também comporta uma saída analógica, que pode ser regulada, de acordo com a sensibilidade do som desejado, semelhante ao módulo ky-037, e envia um sinal de nivel alto para a porta de saída, algumas características são:

Possuir alimentação de 3,3v até 5v;
Possuir 4 pinos machos, da esquerda pra direita são A0 (OUTPUT ANALÓGICO), GND, VCC, e D0 (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;
Possui um potenciomêtro para regular a sensibildiade acionamento do módulo

#define pinKY038_A A0 
#define pinKY038_D 3 

/**
  * Configuração dos pinos do KY-038 como entrada
  **/
void setup () {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);  
  pinMode(pinKY038_A, INPUT);
  pinMode(pinKY038_D, INPUT); 
} 

/**
  * lendo o valor dos pinos e armazenando em variáveis.
  * Se o sensor detectar um som é então acionado, 
  * o valor analógico é impresso na serial.
  **/
void loop () {
  int analogVal = analogRead (pinKY038_A);
  int digVal = digitalRead (pinKY038_D);

  Serial.println(analogVal);

  digitalWrite(LED_BUILTIN, var);
}

Módulo ky-039: Sensor Batimentos cardiacos

Este sensor trata-se de um led IR e um fototransistor, serve para detectar o fluxo de sangue ao por o dedo no meio dele, ele é um módulo que envia um sinal analógico para a porta de saída. Este módulo é difícil de trabalhar pois é possivel encontrar codificações diferentes na internet, além disso, o próprio módulo deve ser ajustado para que o led possa incidir sua luz sobre o fototransistor.

Como eu não pude encontrar uma explicação para o código que encontrei, eu não posso explica-lo, então sugiro pesquisar sobre esse módulo em vídeos ou outras formas, algumas características são:

Possuir alimentação de 5v;
Possuir 3 pinos machos, da esquerda pra direita são SIGNAL (OUTPUT ANALÓGICO), VCC, GND;
Para usar este sensor não é preciso nenhuma biblioteca (embora este era pra ter uma);

// Código copiado da internet
            
int sensorPin = A0;
double alpha = 0.75;
int period = 200;
double change = 0.0;
void setup ()
{
  pinMode (LED_BUILTIN, OUTPUT);
  Serial.begin (9600);
}

void loop ()
{
  static double oldValue = 0;
  static double oldChange = 0;
  int rawValue = analogRead (sensorPin);
  double value = alpha * oldValue + (1 - alpha) * rawValue;
  
  Serial.print (rawValue);
  Serial.print (",");
  Serial.println (value);
  oldValue = value;
  delay (period);
}

Módulo ky-040: Encoder Rotativo

Este módulo trata-se de um encoder rotativo (não confunda com um potênciometro de 10k que é muito comum, este é completamente diferente e tem mais pinos), este módulo é util para obter informações de sentido de rotação (Horário e Anti-horário), posição do encoder e acionamento (ele tem um botão interno), algumas características são:

Possuir alimentação de 3v à 5v;
Possuir 5 pinos machos, da esquerda pra direita são GND, VCC, SW (OUTPUT DIGITAL), DT (OUTPUT DIGITAL), CLK (OUTPUT DIGITAL);
Para usar este sensor não é preciso nenhuma biblioteca;

#define pinKY040_CLK 3
#define pinKY040_DT 4
#define pinKY040_SW 5

int ultimaLeitura;
int delayTime = 1000;

/**
  * Configuração do pino do KY-040 como leitura
  **/
void setup () {
  Serial.begin(9600);
  
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinKY040_CLK, INPUT);
  pinMode(pinKY040_DT, INPUT);
  pinMode(pinKY040_SW, INPUT_PULLUP);
   
  ultimaLeitura = digitalRead(pinKY040_CLK);
}

/**
  *  lendo valor da posição do encoder.
  **/
void loop () {

  int leituraAtual = digitalRead(pinKY040_CLK);
  int val_dt = digitalRead(pinKY040_DT);
  int val_sw = digitalRead(pinKY040_SW);

  Serial.print("Valores: CLK: ");  Serial.print(leituraAtual);
  Serial.print(" | DT: ");  Serial.print(val_dt);  
  Serial.print(" | SW: ");  Serial.print(val_sw);
  Serial.println();
  
  if(leituraAtual != ultimaLeitura){
    if(val_dt == leituraAtual){ // Se for igual é horário
      
      if(delayTime < 2000) delayTime += 100;
    } else { // Se for igual é anti-horário
      
      if(delayTime > 100) delayTime -= 100;
    }
  }
  
  if(val_sw == LOW){ // Low por conta do INPUT_PULLUP
    delayTime = 1000;
  }

  ultimaLeitura = leituraAtual;

  if(delayTime > 100 && delayTime < 2000){
    digitalWrite(LED_BUILTIN, HIGH);
    delay(delayTime);
    digitalWrite(LED_BUILTIN, LOW);
    delay(delayTime);
  }
  
}

E quanto aos outros módulos, do kit 45 in 1?

Vamos abordar eles, entretanto alguns não são módulos e sensores, são mais componentes que podem ser usados para as plataformas arduino, esp8266 entre outros.

Módulo cartão SD

Este módulo trata-se de um módulo para leitura e gravação de arquivos em um cartão de memória (SD Card), funciona também com MicroSD desde que use um adaptador de SD Card. Este módulo opera na tensão de 3v, logo para ligar os pinos de sinal dele ao arduino, é necessário usar um divisor de tensão ou um conversor de nível lógico, algumas características são:

Possuir alimentação de 3v à 5v (entretanto ele opera a 3v);
Possuir 8*2 (2 fileiras) pinos machos, da esquerda pra direita, GND, MISO, SCK/CLK (Opera em 3v), MOSI (Opera em 3v), CS (Opera em 3v), VCC (5v), VCC (3v) e GND;
Para usar este sensor é necessário usar a biblioteca ‘SD’ do arduino e ‘SPI’;

/**
   Necessário importar as bibliotecas do SD e SPI.

   Como o módulo funciona através de 3,3v na comunicação,
   o arduino 5v. Então deve usar divisor de tensão ou conversor de nível lógico nos seguintes:

   Pino CS do módulo na porta 4 do arduino; (Usar divisor de tensão/conversor de nível lógico).
   Pino MOSI do módulo na porta 11 do arduino; (Usar divisor de tensão/conversor de nível lógico).
   Pino MISO do módulo na porta 12 do arduino;
   Pino SCK/CLK do módulo na porta 13 do arduino; (Usar divisor de tensão/conversor de nível lógico).
*/
#include <SPI.h>
#include <SD.h>

#define pinSD 4 // Unico pino que definimos, os outros são padrão


void setup() {

  Serial.begin(9600); // Inicia o monitor serial

  Serial.print("Inicializando o cartão SD...");

  if (!SD.begin(pinSD)) {
    Serial.println("Falha ao iniciar cartão!");
    while (1);
  }
  Serial.println("Feito!");


  /**
     Podia ser feito no loop, mas para executar uma vez
     vou apenas deixar no Setup para não ficar abrindo e escrevendo o arquivo.
  */

  String fileName = "myFile.txt"; // Definimos o nome do arquivo;

  File myFile = SD.open(fileName, FILE_WRITE); // Abre arquivo, e definimos que é para escrever, se não existir ele é criado.

  if (myFile) { // Se tudo der certo, o arquivo é aberto
    Serial.print("Escrevendo arquivo: ");
    Serial.print(fileName);
    Serial.print("...");

    myFile.println("Bem vindo ao cleb.dev"); // Escreve a mensagem no arquivo e pula para a proxima linha.
    myFile.close(); // fechar o arquivo
    Serial.println("Feito!");
  } else { // Senão
    Serial.print("Erro ao abrir ");
    Serial.println(fileName);
  }

  myFile = SD.open(fileName); // Abre o arquivo pra leitura

  if (myFile) { // Se tudo der certo, o arquivo é aberto
    Serial.print("Lendo arquivo: ");
    Serial.println(fileName);

    while (myFile.available()) { // Verifica se existe conteúdo para leitura, enquanto existir...
      Serial.write(myFile.read()); // Escreve na serial os dados
    }
    
    myFile.close(); // fechar o arquivo
  } else {
    Serial.print("Erro ao abrir ");
    Serial.println(fileName);
  }
}

void loop() {}

Módulo Sensor de umidade do solo

Este módulo trata-se de um sensor simples de umidade do solo, medindo a resistência usando o “garfo”, inclui um módulo que permite mudar a sensibilidade da porta digital, emitindo um sinál de nivel alto quando o solo está umido, algumas características são:

Possuir alimentação de 5v;
Possuir 4 pinos machos, da esquerda pra direita, A0 (OUTPUT ANALÓGICO), D0 (OUTPUT DIGITAL), GND e VCC;
Para usar este sensor não é necessário nenhuma biblioteca;
Este sensor não é muito bom para projetos que exigem muita sensibilidade a longo prazo, devido a facilidade de corrosão do “garfinho” dele conforme for usando;

#define pinSensor A0


void setup () {
  Serial.begin(9600);
  pinMode(pinSensor, INPUT); 
} 

void loop () {
  int val = analogRead (pinSensor);
  Serial.print("Valor obtido aproximado >>> ");
  Serial.println(val);
  delay(100); 
}

Módulo Sensor de chuva/Água

Este módulo trata-se de um sensor simples para detectar chuva, que usa o mesmo princípio do sensor de umidade do solo, medindo a resistência da quantidade de gotas usando as “linhas”, algumas características são:

Possuir alimentação de 3v à 5v;
Possuir 3 pinos machos, da esquerda pra direita: GND, VCC e SIGNAL (OUTPUT ANALÓGICO);
Para usar este sensor não é necessário nenhuma biblioteca;

#define pinSensor A0


void setup () {
  Serial.begin(9600);
  pinMode(pinSensor, INPUT); 
} 

void loop () {
  int val = analogRead (pinSensor);
  Serial.print("Valor obtido aproximado >>> ");
  Serial.println(val);
  delay(100); 
}

Módulo Sensor de distância ultrasônico

Este módulo trata-se de um sensor de distância muito usado na robótica, para construir carrinhos e robôs autonomos, mede a distância do sensor para um objeto, usando pulsos ultrasônicos com uma alta sensibilidade, algumas características são:

Possuir alimentação de 5v;
Possui um alcance entre ~2cm até ~3-4 metros em boas condições;
Possuir 4 pinos machos, da esquerda pra direita, VCC, TRIG (INPUT DIGITAL), ECHO (OUTPUT DIGITAL), GND;
Para usar este sensor não é necessário nenhuma biblioteca, entretanto é necessário fazer o seguinte calculo para ter a distância aproximada obtida pelo sensor;

const int pinTRIG = 2; 
const int pinECHO = 3;

//Velocidade do som no ar em 20 *C
const float velSom = 343.0; 

void setup() {
  Serial.begin(9600);
  pinMode(pinTRIG, OUTPUT);
  pinMode(pinECHO, INPUT);
}

void loop() {
  float distancia = calcularDistancia(pinTRIG, pinECHO);
  Serial.print("Distância: "); 
  Serial.print(distancia);
  Serial.println("cm.");
  delay(100);
}

float calcularDistancia(int emissor, int receptor){
  
  digitalWrite(emissor, LOW);
  delayMicroseconds(10); // Tempo seguro para religar
  digitalWrite(emissor, HIGH);
  delayMicroseconds(10);
  digitalWrite(emissor, LOW);
  
  float tempo = pulseIn(receptor, HIGH);
  /**
   * Precisamos alterar a escala da velocidade do som
   * para cm/s, então temos duas opções, dividir 
   * por 10000, ou dividimos por 100 (metros) 
   * e por 100 (centimetros) novamente.
   * assim fica 343.0 / 100 = 3.43, 
   * depois 3.43 / 100 = 0.0343 cm/s
  **/
  return tempo * ((velSom / 100) / 100) / 2;
}

Módulo Sensor Acelerômetro e Giroscópio

Este módulo trata-se de um sensor de movimento o qual é possivel obter dados de aceleração e giroscópio (Ângulos X, Y, Z espaciais). Muito util para projetos autonomos, e além disso possui um sensor de temperatura embutido, algumas características são:

Possuir alimentação de 3v à 5v;
Sensor de temperatura obtém dados entre -40ºC à 85ºC
Possuir 8 pinos machos, da esquerda pra direita, VCC, GND, SLC (I2C), SDA (I2C) (Os mais relevantes são somente os 4 primeiros), o resto sómente se for usar outro sensor para fazer um par;
Para usar este sensor não é necessário nenhuma biblioteca, entretanto para facilitar o trabalho tem bibliotecas que resumem bem o funcionamento do sensor e que facilitam, e muito, o trabalho de manuseio. Uma delas é a MPU6050_tockn;

#include <MPU6050_tockn.h>
#include <Wire.h>

MPU6050 mpu6050(Wire);

void setup() {
  Serial.begin(9600);
  Wire.begin();
  mpu6050.begin();
  mpu6050.calcGyroOffsets(true); // Não mecher no sensor enquanto estiver calibrando
}

void loop() {
  mpu6050.update(); // Sempre chamar antes de pegar os valores
  printAngle();
}

void printTemp() {
  Serial.print("Temp : "); Serial.println(mpu6050.getTemp()); // Temperatura
}

void printAcc() {
  Serial.print("AccX : "); Serial.print(mpu6050.getAccX());
  Serial.print("\tAccY : "); Serial.print(mpu6050.getAccY());
  Serial.print("\tAccZ : "); Serial.println(mpu6050.getAccZ());
}

void printGyro() {
  Serial.print("gyroX : "); Serial.print(mpu6050.getGyroX());
  Serial.print("\tgyroY : "); Serial.print(mpu6050.getGyroY());
  Serial.print("\tgyroZ : "); Serial.println(mpu6050.getGyroZ());
}

void printGyroAngle() {
  Serial.print("gyroAngleX : "); Serial.print(mpu6050.getGyroAngleX());
  Serial.print("\tgyroAngleY : "); Serial.print(mpu6050.getGyroAngleY());
  Serial.print("\tgyroAngleZ : "); Serial.println(mpu6050.getGyroAngleZ());
}

void printAngle() {
  Serial.print("angleX : "); Serial.print(mpu6050.getAngleX());
  Serial.print("\tangleY : "); Serial.print(mpu6050.getAngleY());
  Serial.print("\tangleZ : "); Serial.println(mpu6050.getAngleZ());
}

Módulo Real Time Clock DS1302

Este módulo nos permite obter informações de data e hora em tempo real, além disso, para usar corretamente é necessário usar junto uma pilha compatível, de modo que as informações de data e hora não se percam quando o arduino for desligado, algumas características são:

Possuir alimentação de 3v à 5v (Apesar de que com 5v eu tive algumas leitura erradas, funcionando apenas com 3v mais correntamente);
Possuir 5 pinos machos, da esquerda pra direita, VCC, GND, CLK, DAT e RST;
Para usar este módulo é necessário usar a biblioteca do RtcDS1302 pelo Makuma;
Como não sei muito deste módulo, o código usado é o exemplo da própria biblioteca:

// CONNECTIONS:
// DS1302 CLK/SCLK --> 5
// DS1302 DAT/IO --> 4
// DS1302 RST/CE --> 2
// DS1302 VCC --> 3.3v - 5v
// DS1302 GND --> GND

#include <ThreeWire.h>  
#include <RtcDS1302.h>

ThreeWire myWire(4,5,2); // IO, SCLK, CE
RtcDS1302<ThreeWire> Rtc(myWire);

void setup () 
{
    Serial.begin(9600);

    Serial.print("compiled: ");
    Serial.print(__DATE__);
    Serial.println(__TIME__);

    Rtc.Begin();

    RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
    printDateTime(compiled);
    Serial.println();

    if (!Rtc.IsDateTimeValid()) 
    {
        // Common Causes:
        //    1) first time you ran and the device wasn't running yet
        //    2) the battery on the device is low or even missing

        Serial.println("RTC lost confidence in the DateTime!");
        Rtc.SetDateTime(compiled);
    }

    if (Rtc.GetIsWriteProtected())
    {
        Serial.println("RTC was write protected, enabling writing now");
        Rtc.SetIsWriteProtected(false);
    }

    if (!Rtc.GetIsRunning())
    {
        Serial.println("RTC was not actively running, starting now");
        Rtc.SetIsRunning(true);
    }

    RtcDateTime now = Rtc.GetDateTime();
    if (now < compiled) 
    {
        Serial.println("RTC is older than compile time!  (Updating DateTime)");
        Rtc.SetDateTime(compiled);
    }
    else if (now > compiled) 
    {
        Serial.println("RTC is newer than compile time. (this is expected)");
    }
    else if (now == compiled) 
    {
        Serial.println("RTC is the same as compile time! (not expected but all is fine)");
    }
}

void loop () 
{
    RtcDateTime now = Rtc.GetDateTime();

    printDateTime(now);
    Serial.println();

    if (!now.IsValid())
    {
        // Common Causes:
        //    1) the battery on the device is low or even missing and the power line was disconnected
        Serial.println("RTC lost confidence in the DateTime!");
    }

    delay(5000); // five seconds
}

#define countof(a) (sizeof(a) / sizeof(a[0]))

void printDateTime(const RtcDateTime& dt)
{
    char datestring[20];

    snprintf_P(datestring, 
            countof(datestring),
            PSTR("%02u/%02u/%04u %02u:%02u:%02u"),
            dt.Month(),
            dt.Day(),
            dt.Year(),
            dt.Hour(),
            dt.Minute(),
            dt.Second() );
    Serial.print(datestring);
}

Módulo de alimentação MB102

Este módulo nos permite alimentar energéticamente, os componentes eletronicos na nossa placa protoboard, ao conectar a entrada de 7 à 12 volts, possuindo 2 voltagens de saída como 5v e 3v, algumas características são:

Input de 7 à 12 volts;
Sáida configurável de 3v à 5v usando os jumpers;
Entrada USB para carregamento;

Mini Conversor de Tensão DC-DC Step Down

Este módulo que permite regular a tensão de saída através de um trimpod conectado na placa. Este módulo é pequeno e para tensões e corrente mais altas que superam os 2 ampéres, é necessário usar um dissipador, algumas características são:

Input de 5v à 28 volts;
Saída de 0.8v à 20 volts;
Corrente máxima de 2A ampéres (3A no máximo se usar um bom dissipador);

Com isso terminaos este post sobre os itens que vem nos Kits 37 in 1 e 45 in 1 para arduino, espero que todos curtam o conteúdo e na proxima teremos mais coisas a abordar.

v1.9.5 cleb.dev

Postado em: 02-12-2022 às 06:01:51 PM